home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / mint / gcc / gcc261a.zoo / info / libobjects < prev   
Encoding:
GNU Info File  |  1994-11-18  |  62.1 KB  |  1,785 lines
  1. This is Info file libobjects.info, produced by Makeinfo-1.55 from the
  2. input file ./libobjects.texi.
  3.  
  4. START-INFO-DIR-ENTRY
  5. * Libobjects::                      The GNU Objective C Class Library.
  6. END-INFO-DIR-ENTRY
  7.  
  8.    This file documents the features and implementation of The GNU
  9. Objective-C class library.
  10.  
  11.    Copyright (C) 1993 Free Software Foundation, Inc.
  12.  
  13.    Permission is granted to make and distribute verbatim copies of this
  14. manual provided the copyright notice and this permission notice are
  15. preserved on all copies.
  16.  
  17.    Permission is granted to copy and distribute modified versions of
  18. this manual under the conditions for verbatim copying, provided also
  19. that the section entitled "GNU Library General Public License" is
  20. included exactly as in the original, and provided that the entire
  21. resulting derived work is distributed under the terms of a permission
  22. notice identical to this one.
  23.  
  24.    Permission is granted to copy and distribute translations of this
  25. manual into another language, under the above conditions for modified
  26. versions, except that the section entitled "GNU Library General Public
  27. License" and this permission notice may be included in translations
  28. approved by the Free Software Foundation instead of in the original
  29. English.
  30.  
  32. File: libobjects.info,  Node: Top,  Next: Copying,  Up: (DIR)
  33.  
  34. Libobjects
  35. **********
  36.  
  37.    This manual documents how to install and use the GNU Objective-C
  38. Class Library (or `libobjects'), version {No Value For
  39. "LIBOBJECTS_VERSION"}, for use with `gcc' version {No Value For
  40. "GCC_VERSION"}.
  41.  
  42.    It is nothing but a skeleton now, mostly containing rough notes.  In
  43. the future it will be fleshed out and the text will be polished.
  44.  
  45. * Menu:
  46.  
  47. * Copying::        GNU Library Public License says how you can copy
  48.                     and share libobjects.
  49. * Contributors::    People who have contributed to libobjects.
  50. * Installation::    How to configure, compile and install libobjects.
  51. * Trouble::         If you have trouble installing libobjects.
  52.  
  53. * Overview::        libobjects in brief.
  54. * Organization::    The heirarchy of protocols and classes.
  55. * Conventions::     Stylistic conventions and design philosophy.
  56. * Content Types::   Collections can contain C types as well as objects.
  57.  
  58. * Creating::        Creating a collection.
  59. * Freeing::         Freeing a collection or its elements.
  60. * Adding::          Adding elements to a collection.
  61. * Removing::        Removing elements from a collection.
  62. * Replacing::       Replacing elements in a collection.
  63. * Enumerating::     Performing an operation with all elements.
  64. * Duplicating::     Making a copy of a collection.
  65. * Archiving::       Writing (and reading) a collection to (from) a file.
  66. * Querying::        Asking questions about a collection and its contents.
  67. * Sorting::         Sorting the contents of a collection.
  68.  
  69. * Classes::         Choosing the class with the features you need.
  70.  
  71. * Projects::        To do list and questions for users.
  72.  
  73. * Protocol Index::
  74. * Class Index::
  75. * Method Function Macro Index::
  76. * Concept Index::
  77.  
  79. File: libobjects.info,  Node: Copying,  Next: Contributors,  Prev: Top,  Up: Top
  80.  
  81. Copying
  82. *******
  83.  
  84.    See the file `COPYING.LIB'.
  85.  
  87. File: libobjects.info,  Node: Contributors,  Next: Installation,  Prev: Copying,  Up: Top
  88.  
  89. Contributors to GNU Objective-C Collection library
  90. **************************************************
  91.  
  92.    * Andrew McCallum <mccallum@gnu.ai.mit.edu> designed the protocol and
  93.      class heirarchies, and wrote the otherwise unattributed classes.
  94.  
  95.    * Kresten Krab Thorup <Kresten_Thorup@NeXT.COM> made libobjects
  96.      possible by writing the GNU Objective-C runtime.  He also
  97.      contributed the GapArray and Storage classes.  He also wrote
  98.      patches to texinfo that make `deftypemethod' possible.
  99.  
  100.    * Adam Fedor <fedor@boulder.colorado.edu> wrote the NXStringTable
  101.      class.
  102.  
  103.    * Paul Kunz <Paul_Kunz@slac.stanford.edu> did a lot to fix the List
  104.      class.
  105.  
  106.    * Kresten Krab Thorup <krab@iesd.auc.dk>, Paul Burchard
  107.      <burchard@geom.umn.edu>, Paul Kunz <Paul_Kunz@slac.stanford.edu>,
  108.      Geoffery Knauth <gsk@marble.com>, Steve Naroff <snaroff@next.com>,
  109.      Richard Stallman <rms@gnu.ai.mit.edu> and others contributed to
  110.      discussions about the library.
  111.  
  113. File: libobjects.info,  Node: Installation,  Next: Trouble,  Prev: Contributors,  Up: Top
  114.  
  115. Installing GNU Objective-C Class Library
  116. ****************************************
  117.  
  118.    To compile and install `libobjects':
  119.  
  120.   1. Install `gcc'.  The library requires gcc version
  121.      2.6.1 or later.
  122.  
  123.   2. Configure the package for your system.  In the directory that this
  124.      file is in, type `./configure'.  If you're using `csh' on an old
  125.      version of System V, you might need to type `sh configure' instead
  126.      to prevent `csh' from trying to execute `configure' itself.
  127.  
  128.      If you are compiling the library for a NeXT machine, you have the
  129.      choice of using either the GNU or the NeXT Objective C runtime.
  130.      You can specify this by setting CFLAGS.  For example:
  131.           CFLAGS=-fgnu-runtime ./configure
  132.  
  133.      The `configure' shell script attempts to guess correct values for
  134.      various system-dependent variables used during compilation, and
  135.      creates the Makefile(s) (one in each subdirectory of the source
  136.      directory).  In some packages it creates a C header file
  137.      containing system-dependent definitions.  It also creates a file
  138.      `config.status' that you can run in the future to recreate the
  139.      current configuration.
  140.  
  141.      Running `configure' takes less than a minute or two.  While it is
  142.      running, it prints some messages that tell what it is doing.  If
  143.      you don't want to see the messages, run `configure' with its
  144.      standard output redirected to `/dev/null'; for example:
  145.           ./configure >/dev/null
  146.  
  147.      To compile the package in a different directory from the one
  148.      containing the source code, you must use a version of make that
  149.      supports the VPATH variable, such as GNU make.  `cd' to the
  150.      directory where you want the object files and executables to go
  151.      and run `configure'.  `configure' automatically checks for the
  152.      source code in the directory that `configure' is in and in `..'.
  153.      If for some reason `configure' is not in the source code directory
  154.      that you are configuring, then it will report that it can't find
  155.      the source code.  In that case, run `configure' with the option
  156.      `--srcdir=DIR', where DIR is the directory that contains the
  157.      source code.
  158.  
  159.      By default, `make install' will install the package's files in
  160.      /usr/local/bin, /usr/local/lib, /usr/local/man, etc.  You can
  161.      specify an installation prefix other than /usr/local by giving
  162.      `configure' the option `--prefix=PATH'.  Alternately, you can do
  163.      so by giving a value for the `prefix' variable when you run
  164.      `make', e.g.,
  165.           make prefix=/usr/gnu
  166.  
  167.      You can specify separate installation prefixes for
  168.      architecture-specific files and architecture-independent files.
  169.      If you give `configure' the option `--exec_prefix=PATH' or set the
  170.      `make' variable `exec_prefix' to PATH, the package will use PATH
  171.      as the prefix for installing programs and libraries.  Data files
  172.      and documentation will still use the regular prefix.  Normally,
  173.      all files are installed using the regular prefix.
  174.  
  175.      You can tell `configure' to figure out the configuration for your
  176.      system, and record it in `config.status', without actually
  177.      configuring the package (creating `Makefile's and perhaps a
  178.      configuration header file).  To do this, give `configure' the
  179.      `--no-create' option.  Later, you can run `./config.status' to
  180.      actually configure the package.  This option is useful mainly in
  181.      `Makefile' rules for updating `config.status' and `Makefile'.  You
  182.      can also give `config.status' the `--recheck' option, which makes
  183.      it re-run `configure' with the same arguments you used before.
  184.      This is useful if you change `configure'.
  185.  
  186.      `configure' ignores any other arguments that you give it.
  187.  
  188.      If your system requires unusual options for compilation or linking
  189.      that `configure' doesn't know about, you can give `configure'
  190.      initial values for some variables by setting them in the
  191.      environment.  In Bourne-compatible shells, you can do that on the
  192.      command line like this:
  193.           CC='gcc -traditional' DEFS=-D_POSIX_SOURCE ./configure
  194.  
  195.      The `make' variables that you might want to override with
  196.      environment variables when running `configure' are:
  197.  
  198.      (For these variables, any value given in the environment overrides
  199.      the value that `configure' would choose:)
  200.     `CC'
  201.           C compiler program.  Default is `cc', or `gcc' if `gcc' is in
  202.           your PATH.
  203.  
  204.     `INSTALL'
  205.           Program to use to install files.  Default is `install' if you
  206.           have it, `install.sh' otherwise.
  207.  
  208.      (For these variables, any value given in the environment is added
  209.      to the value that `configure' chooses:)
  210.     `DEFS'
  211.           Configuration options, in the form `-Dfoo -Dbar ...'
  212.  
  213.     `LIBS'
  214.           Libraries to link with, in the form `-lfoo -lbar ...'
  215.  
  216.      If you need to do unusual things to compile the package, we
  217.      encourage you to figure out how `configure' could check whether to
  218.      do them, and mail diffs or instructions to the address given in
  219.      the `README' so we can include them in the next release.
  220.  
  221.   3. Type `make' to compile the package.  If you want, you can override
  222.      the `make' variables `CFLAGS' and `LDFLAGS' like this:
  223.               make CFLAGS=-O2 LDFLAGS=-s
  224.  
  225.      You will get some warnings from `#warning' lines I've added to the
  226.      code.  Ignore them.
  227.  
  228.      You may get some warnings like `stdobjects.m:0: warning:
  229.      `_OBJC_SELECTOR_TABLE' defined but not used'.  Ignore them.  They
  230.      are bogus warnings due to a bug in cc1obj.
  231.  
  232.      You may get some warnings like `ar: filename BinaryTreeEltNode.o
  233.      truncated to BinaryTreeEltNo'.  Ignore them.
  234.  
  235.   4. If you want to compile the self-tests, cd to `checks' and type
  236.      `make'.  If you want to compile the examples, cd to `examples' and
  237.      type `make'.
  238.  
  239.   5. Type `make install' to install programs, data files, and
  240.      documentation.
  241.  
  242.   6. You can remove the program binaries and object files from the
  243.      source directory by typing `make clean'.  To also remove the
  244.      Makefile(s), and `config.status' (all the files that `configure'
  245.      created), type `make distclean'.
  246.  
  247.      The file `configure.in' is used as a template to create
  248.      `configure' by a program called `autoconf'.  You will only need it
  249.      if you want to regenerate `configure' using a newer version of
  250.      `autoconf'.
  251.  
  252.  
  254. File: libobjects.info,  Node: Trouble,  Next: Overview,  Prev: Installation,  Up: Top
  255.  
  256. Trouble in Installation
  257. ***********************
  258.  
  259.    Try to fix the problem.  Send patches to mccallum@gnu.ai.mit.edu.
  260.  
  261.    <<This section incomplete>>
  262.  
  264. File: libobjects.info,  Node: Overview,  Next: Organization,  Prev: Trouble,  Up: Top
  265.  
  266. Overview
  267. ********
  268.  
  269.    The GNU classes included in this version of the library fall into
  270. five categories: collections, magnitudes, streams, coders and remote
  271. messaging support.
  272.  
  273.    * The collection objects all conform to the `Collecting' protocol.
  274.      Reading `./objects/Collecting.h' is a good place to start.
  275.      Protocols for collections that store their contents with keys and
  276.      with indices can be found in `./objects/KeyedCollecting.h' and
  277.      `./objects/IndexedCollecting.h' respectively.  Examples of generic
  278.      collections are `Set' and `Bag'.  The keyed collections are
  279.      `Dictionary' and `MappedCollector'.  The classes `Array', `Queue',
  280.      `GapArray', `LinkedList', `BinaryTree', `RBTree' and `SplayTree'
  281.      are all indexed collections.
  282.  
  283.    * The useful magnitude classes are `Time' and `Random'.  The
  284.      `Random' class works in conjunction with pseudo-random number
  285.      generators that conform to the `RandomGenerating' protocol.  The
  286.      conforming class `RNGBerkeley' provides identical behavior to the
  287.      BSD random() function.  The class `RNGAdditiveCongruential' is an
  288.      implementation of the additive congruential method.
  289.  
  290.    * Stream objects provide a consistent interface for reading and
  291.      writing bytes.  Read `./objects/Stream.h' to get the general idea.
  292.      `StdioStream' objects work with files, file descriptors, FILE
  293.      pointers and pipes to executables.  `MemoryStream' objects work
  294.      with memory buffers.
  295.  
  296.    * Coders provide a formatted way of writing to Streams.  After a
  297.      coder is initialized with a stream, the coder can encode/decode
  298.      Objective C objects and C types.  See `./objects/Coder.h' for the
  299.      abstract superclass interface; see `./objects/Coding.h' for the
  300.      protocol adopted by objects that read and write themselves using
  301.      coders.  The currently available concrete coders are
  302.      `BinaryCoder', for reading and writing a compact stream of
  303.      illegible bytes, and `TextCoder', for reading and writing
  304.      human-readable text.
  305.  
  306.      Coders and streams can be mixed and matched so that programmers can
  307.      choose the destination and the format separately.
  308.  
  309.      Neither the stream or coder class heirarchies are very mature yet.
  310.      I threw them together because I needed them for remote object
  311.      messaging.
  312.  
  313.    * The remote object messaging support classes are `Connection',
  314.      `Proxy', `ConnectedCoder', `Port' and `SocketPort'.
  315.  
  317. File: libobjects.info,  Node: Organization,  Next: Conventions,  Prev: Overview,  Up: Top
  318.  
  319. Organization
  320. ************
  321.  
  322.    The library is built around several protocols:
  323.  
  324.    * The <Collecting> protocol is root of the collection protocol
  325.      heirarchy.  The <Collecting> protocol defines the most general
  326.      interface to a collection of elements.  Elements can be added,
  327.      removed, and replaced.  The contents can be tested, enumerated,
  328.      and enumerated through various filters.  Elements may be objects,
  329.      or any C type included in the "elt" union given in elt.h, but all
  330.      elements of a collection must be of the same C type.  (For
  331.      examples see Set and Bag.)
  332.  
  333.    * The <KeyedCollecting> protocol inherits from the <Collecting>
  334.      protocol.  The <KeyedCollecting> protocol defines the interface to
  335.      a collection of elements that are accessible by a key, where the
  336.      key is some unique element.  Pairs of (key element, content
  337.      element) may be added, removed and replaced.  The keys and
  338.      contents may be tested, enumerated, and copied.  (For examples see
  339.      Dictionary and MappedCollector.)
  340.  
  341.    * The <IndexedCollecting> protocol inherits from the
  342.      <KeyedCollecting> protocol.  The <IndexedCollecting> protocol
  343.      defines the interface to a collection of elements that are
  344.      accessible by a key that is an index, where the indeces in a
  345.      collection are a contiguous series of unsigned integers beginning
  346.      at 0.  This is the root of the protocol heirarchy for all
  347.      collections that hold their elements in some order.  Elements may
  348.      be accessed, inserted, replaced and removed by their index.  (For
  349.      examples see Array and LinkedList.)
  350.  
  351.    * The <LinkedListComprising> protocol defines the interface to an
  352.      object that may be an element in a LinkedList.  LinkedList is a
  353.      collection object based on a doubly linked list.  (For an example
  354.      see LinkedListNode.)
  355.  
  356.    * The <BinaryTreeComprising> protocol defines the interface to an
  357.      object that may be an element in a BinaryTree.  BinaryTree is a
  358.      collection object based on a binary trees.  (For an example see
  359.      BinaryTreeNode.)
  360.  
  361.    Here is the object inheritance heirarchy.  All collection abtract
  362. superclasses (classes which are not usable without subclassing) end
  363. with "Collection"; all protocols end with "ing"; all collection
  364. protocols end with "Collecting".
  365.  
  366.         Collection <Collecting>
  367.             Set
  368.                 Bag
  369.             KeyedCollection <KeyedCollecting>
  370.                 Dictionary
  371.                 MappedCollector
  372.                 IndexedCollection <IndexedCollecting>
  373.                     Array
  374.                         Stack
  375.                         GapArray
  376.                         CircularArray
  377.                             Queue
  378.                         Heap
  379.                     LinkedList
  380.                     BinaryTree
  381.                     RBTree
  382.                     EltNodeCollector
  383.                     String
  384.          DelegateList
  385.      
  386.          HashTable
  387.          List
  388.          Storage
  389.  
  390.    <<This section unfinished.>>
  391.  
  393. File: libobjects.info,  Node: Conventions,  Next: Content Types,  Prev: Organization,  Up: Top
  394.  
  395. Stylistic Conventions and Design Philosophy
  396. *******************************************
  397.  
  398. Stylistic Conventions
  399. =====================
  400.  
  401.    * Objective-C source files have file extension `.m'. Both
  402.      C-compatibility header files and class declaration files have
  403.      extension `.h'.
  404.  
  405.    * Objective-C class names begin with capital letters.  Multi-word
  406.      class names capitalize each word, with no underscore separation.
  407.  
  408.    * Include files that define Objective-C classes begin with capital
  409.      letters (as do the names of the classes themselves).
  410.  
  411.    * All protocols end with `ing'.  All collection protocols end with
  412.      `Collecting'.  All collection abtract superclasses (classes which
  413.      are not usable without subclassing) end with `Collection'.
  414.  
  415.    * Include files that supply function prototypes for other C
  416.      functions are all lower case.
  417.  
  418.    * Instance variables begin with an underscore, are all lower case,
  419.      and have underscores separating their component words.  The leading
  420.      underscore distinguishes them from local varibles defined inside
  421.      methods.
  422.  
  423.    * All include files define a preprocessor variable __X_h_INCLUDE_GNU,
  424.      where X is the name of the file, and conditionally compile only if
  425.      this has not been already defined.
  426.  
  427.    * The following macros and variables make the relevant version
  428.      numbers available:
  429.  
  430.       - Macro: COLL_VERSION
  431.           The version number of the collection library.  Declared in
  432.           `coll/collstd.h'
  433.  
  434.       - Macro: COLL_GCC_VERSION
  435.           The version number of the compiler used to compile the
  436.           collection library.  Declared in `coll/collstd.h'
  437.  
  438.       - Variable: char[] coll_version
  439.           A string containing the version number of the collection
  440.           library.  Declared in `coll/collstd.h'
  441.  
  442.       - Variable: char[] coll_gcc_version
  443.           A string containing the version number of the compiler used
  444.           to compile the collection library.  Declared in
  445.           `coll/collstd.h'
  446.  
  447. The design philosophy.
  448. ======================
  449.  
  450.    Objective-C is not Smalltalk.  Differences that matter to the
  451. Collection heirarchy:
  452.  
  453.    * There can be only one set of argument types with each selector.
  454.      (For instance in Objective-C we can't have "-(double)data" and
  455.      "-(char)data".  I can't stand it when some library that I'm forced
  456.      to load already defines a selector that I want to use with
  457.      different types.)  This isn't an issue in Smalltalk because
  458.      everything is an object.
  459.  
  460.      I make the Collection method names a little more descriptive, while
  461.      keeping them close to Smalltalk.  (For instance I think there is a
  462.      good reason for using "-addObject:" instead of "-add:")
  463.  
  464.    * We will want collections of int's, float's, and other non-Objects.
  465.      Using Objective C wrappers around these C primitive types (i.e.
  466.      Integer and Float objects) is not an efficient enough option for
  467.      all cases.
  468.  
  469.      We could create two parallel heirarchies, one for Objects and one
  470.      for elements passed as void*, but since so much of the
  471.      functionality overlaps, I have merged them, and it doesn't
  472.      actually look all that bad.
  473.  
  474.    * Objective C doesn't have Smalltalk Blocks.
  475.  
  476.      Passing pointers to functions is a reasonable substitute.  This is
  477.      made easier with gcc's nested functions and the LAMBDA() macro
  478.      defined in coll/collstd.h.
  479.  
  480.    * Smalltalk does automatic garbage collection; Objective C doesn't.
  481.  
  482.      I think it should be made obvious which methods allocate a new
  483.      object.  Hence "-shallowCopyAs:[Bag class]" instead of "as:[Bag
  484.      class]".
  485.  
  486.    * We have usable Collection classes (Set, Bag, Array, etc) with
  487.      functionality matching Smalltalk's objects, but there are good
  488.      reasons for not having the abstract superclass structure match
  489.      Smalltalk exactly.
  490.  
  491.    <<This section unfinished.>>
  492.  
  494. File: libobjects.info,  Node: Content Types,  Next: Creating,  Prev: Conventions,  Up: Top
  495.  
  496. Content types
  497. *************
  498.  
  499.    Collections can hold either objects or primitive C types.  More
  500. specifically, collections can hold any of the types in the `elt' union
  501. defined in `coll/elt.h'.  All contents of a collection must be of the
  502. same type.
  503.  
  504.    You declare which type the collection will hold at collection
  505. initialization time, and the type can not be changed later.  You
  506. specify the type using the Objective-C `@encode()' directive.  You can
  507. find out the type held by a collection with the method
  508. `contentEncoding' (*note Querying::.).
  509.  
  510.    Many operations are independent of the type the collection holds.
  511. For example the method `-(unsigned)count' returns the number of members
  512. in the collection.
  513.  
  514.    Other operations need to take arguments of different types depending
  515. on whether the contents are objects or some other type.  In this case
  516. there will be two methods, distinguished by the words `Object' and
  517. `Element' in their method name.  For example, `-removeObject:anObject'
  518. vs `-(elt)removeElement:(elt)anElement'.
  519.  
  520.    <<Unfinished.>>
  521.  
  523. File: libobjects.info,  Node: Creating,  Next: Freeing,  Prev: Content Types,  Up: Top
  524.  
  525. Creating a Collection
  526. *********************
  527.  
  528. * Menu:
  529.  
  530. * Basic Creating::
  531. * Keyed Creating::
  532.  
  534. File: libobjects.info,  Node: Basic Creating,  Next: Keyed Creating,  Up: Creating
  535.  
  536. Basic Creating
  537. ==============
  538.  
  539.  - Method on Collection:  -init
  540.  
  541.  - Method on Collection:  -initEncoding: (const char *)CONTENTENCODING
  542.  
  543.    Create with `alloc' and `init'.  Specify the type of contents using
  544. `initEncoding:'.  For example:
  545.  
  546.      id arrayHoldingInts = [[Array alloc] initEncoding:@encode(int)];
  547.  
  548.    <<This section unfinished.>>
  549.  
  551. File: libobjects.info,  Node: Keyed Creating,  Prev: Basic Creating,  Up: Creating
  552.  
  553. Keyed Creating
  554. ==============
  555.  
  557. File: libobjects.info,  Node: Freeing,  Next: Adding,  Prev: Creating,  Up: Top
  558.  
  559. Freeing a Collection or its Elements
  560. ************************************
  561.  
  562.    You can free all the objects in a collection and empty it using
  563. `freeObjects'.  You can emtpy a collection without freeing the contents
  564. using `empty'.  You can free a collection without freeing the contents
  565. using `free'.
  566.  
  567.    <<This section unfinished.>>
  568.  
  570. File: libobjects.info,  Node: Adding,  Next: Removing,  Prev: Freeing,  Up: Top
  571.  
  572. Adding Elements to a Collection
  573. *******************************
  574.  
  575.    Talk about adding.
  576.  
  577. * Menu:
  578.  
  579. * Basic Adding::
  580. * Keyed Adding::
  581. * Indexed Adding::
  582.  
  584. File: libobjects.info,  Node: Basic Adding,  Next: Keyed Adding,  Up: Adding
  585.  
  586. Basic Adding
  587. ============
  588.  
  589.    Adding, adding if absent, adding a copy, adding all contents of
  590. another collection, adding contents if absent, adding with varargs.
  591.  
  592.  - Method on Collection:  -addObject: NEWOBJECT
  593.  - Method on Collection:  -addElement: (elt)NEWELEMENT
  594.      Adds NEWOBJECT to the receiving collection.  Returns self.
  595.  
  596.  - Method on Collection:  -addObjectIfAbsent: NEWOBJECT
  597.  - Method on Collection:  -addElementIfAbsent: (elt)NEWELEMENT
  598.      Adds NEWOBJECT to the receiving collection only if NEWOBJECT isn't
  599.      there already.  Returns self.
  600.  
  601.  - Method on Collection:  -addContentsOf: (id <Collecting>)NEWOBJECT
  602.      Adds all the elements in ACOLLECTION to the receiving collection.
  603.      Returns self.
  604.  
  605.  - Method on Collection:  -addContentsOfIfAbsent: (id
  606.           <Collecting>)NEWOBJECT
  607.      <<Undocumented>>  Returns self.
  608.  
  609.  - Method on Collection:  -addObjectsCount: (unsigned)COUNT, ...
  610.  - Method on Collection:  -addElementsCount: (unsigned)COUNT, ...
  611.      <<Undocumented>>  Returns self.
  612.  
  613.      Here is an example
  614.           id o1 = [[Foo alloc] init];
  615.           id o2 = [[Bar alloc] init];
  616.           id myArray = [[[Array alloc] init] addObjectsCount: 2, o1, o2];
  617.  
  619. File: libobjects.info,  Node: Keyed Adding,  Next: Indexed Adding,  Prev: Basic Adding,  Up: Adding
  620.  
  621. Keyed Adding
  622. ============
  623.  
  624.    If the collection's contents are accessible by a key, members can be
  625. inserted at a specified key.  See KeyedCollecting protocol.
  626.  
  627.  - Method on KeyedCollection:  -insertObject: NEWCONTENTOBJECT atKey:
  628.           (elt)AKEY
  629.  - Method on KeyedCollection:  -insertElement: (elt)NEWCONTENTELEMENT
  630.           atKey: (elt)AKEY
  631.      <<Undocumented>>  returns self.
  632.  
  634. File: libobjects.info,  Node: Indexed Adding,  Prev: Keyed Adding,  Up: Adding
  635.  
  636. Indexed Adding
  637. ==============
  638.  
  639.    Furthermore, if the collections contents are accessible by an index
  640. (an unsigned integer key), members can be appended, prepended.  Inserted
  641. members push other members down to make room.  See IndexedCollecting
  642. protocol.
  643.  
  644.  - Method on IndexedCollection:  -insertObject: NEWOBJECT atIndex:
  645.           (unsigned)INDEX
  646.  - Method on IndexedCollecting:  -insertElement: (elt)NEWELEMENT
  647.           atIndex: (unsigned)INDEX
  648.      <<Undocumented>>  returns self.
  649.  
  650.  - Method on IndexedCollection:  -insertObject: NEWOBJECT before:
  651.           OLDOBJECT
  652.  - Method on IndexedCollecting:  -insertElement: (elt)NEWELEMENT
  653.           before: OLDOBJECT
  654.      <<Undocumented>>  returns self.
  655.  
  656.  - Method on IndexedCollection:  -insertObject: NEWOBJECT after:
  657.           OLDOBJECT
  658.  - Method on IndexedCollecting:  -insertElement: (elt)NEWELEMENT after:
  659.           OLDOBJECT
  660.      <<Undocumented>>  returns self.
  661.  
  662.  - Method on IndexedCollection:  insertContentsOf: (id
  663.           <Collecting>)ACOLLECTION atIndex: (unsigned)INDEX
  664.      <<Undocumented>>  returns self.
  665.  
  666.  - Method on IndexedCollection:  -appendObject: NEWOBJECT
  667.  - Method on IndexedCollecting:  -appendElement: (elt)NEWELEMENT
  668.  - Method on IndexedCollection:  -prependObject: NEWOBJECT
  669.  - Method on IndexedCollecting:  -prependElement: (elt)NEWELEMENT
  670.      <<Undocumented>>  returns self.
  671.  
  672.  - Method on IndexedCollection:  -appendContentsOf: (id
  673.           <Collecting>)ACOLLECTION
  674.  - Method on IndexedCollection:  -prependContentsOf: (id
  675.           <Collecting>)ACOLLECTION
  676.      <<Undocumented>>  returns self.
  677.  
  678.    <<This section unfinished.>>
  679.  
  681. File: libobjects.info,  Node: Removing,  Next: Replacing,  Prev: Adding,  Up: Top
  682.  
  683. Removing Elements from a Collection
  684. ***********************************
  685.  
  686.    About removing...
  687.  
  688. * Menu:
  689.  
  690. * Basic Removing::
  691. * Keyed Removing::
  692. * Indexed Removing::
  693.  
  695. File: libobjects.info,  Node: Basic Removing,  Next: Keyed Removing,  Up: Removing
  696.  
  698. File: libobjects.info,  Node: Keyed Removing,  Next: Indexed Removing,  Prev: Basic Removing,  Up: Removing
  699.  
  701. File: libobjects.info,  Node: Indexed Removing,  Prev: Keyed Removing,  Up: Removing
  702.  
  703.    <<This section unfinished.>>
  704.  
  706. File: libobjects.info,  Node: Replacing,  Next: Enumerating,  Prev: Removing,  Up: Top
  707.  
  708. Replacing Elements in a Collection
  709. **********************************
  710.  
  711. * Menu:
  712.  
  713. * Basic Replacing::
  714. * Keyed Replacing::
  715. * Indexed Replacing::
  716.  
  718. File: libobjects.info,  Node: Basic Replacing,  Next: Keyed Replacing,  Up: Replacing
  719.  
  721. File: libobjects.info,  Node: Keyed Replacing,  Next: Indexed Replacing,  Prev: Basic Replacing,  Up: Replacing
  722.  
  724. File: libobjects.info,  Node: Indexed Replacing,  Prev: Keyed Replacing,  Up: Replacing
  725.  
  726.    <<This section unfinished.>>
  727.  
  729. File: libobjects.info,  Node: Enumerating,  Next: Duplicating,  Prev: Replacing,  Up: Top
  730.  
  731. Enumerating the Contents of a Collection
  732. ****************************************
  733.  
  734.    Enumeration methods allow you to perform a specified operation on the
  735. members of a collection.  You can operate on all the members, operate on
  736. all the members until a flag is set, operate only on the members that
  737. pass some test, or operate on the results of passing the members through
  738. a modifying function.  Each of the enumerators come in pairs: one method
  739. for enumerating in place, and another method that is "safe" for
  740. enumerating when the operation changes the contents of the receiving
  741. collection.  If the contents of the collection are changed during the
  742. enumeration you must use the "safe" methods.
  743.  
  744. * Menu:
  745.  
  746. * Safe vs Unsafe Enumerating::  Enumerations while changing the contents
  747.  
  748. * Basic Enumerating::           Enumerations available for all collections
  749. * Keyed Enumerating::           Enumerations on collections with keys
  750. * Indexed Enumerating::         Enumerations on ordered collections
  751.  
  752. * LAMBDA::                      Defining functions in place with LAMBDA()
  753.  
  755. File: libobjects.info,  Node: Safe vs Unsafe Enumerating,  Next: Basic Enumerating,  Up: Enumerating
  756.  
  757. Safe vs Unsafe Enumerating
  758. ==========================
  759.  
  760.    The simple enumerators operate on the collection in-place.  If the
  761. contents of the collection change during the enumeration, you must use
  762. the "safe" version of the enumerator instead.
  763.  
  764.    It works by making a shallow copy of the receiver, performing the
  765. enumeration using the shallow copy, then freeing the shallow copy.
  766.  
  767.    All enumerators have both "safe" and plain versions.
  768.  
  769.    <<This section unfinished.>>
  770.  
  772. File: libobjects.info,  Node: Basic Enumerating,  Next: Keyed Enumerating,  Prev: Safe vs Unsafe Enumerating,  Up: Enumerating
  773.  
  774. Basic Enumerating
  775. =================
  776.  
  777.    The most basic enumerator is
  778.  
  779.  - Method on Collection:  -withObjectsCall: (void(*)(id))FUNC
  780.  - Method on Collection:  -safeWithObjectsCall: (void(*)(id))FUNC
  781.  - Method on Collection:  -withElementsCall: (void(*)(elt))FUNC
  782.  - Method on Collection:  -safeWithElementsCall: (void(*)(elt))FUNC
  783.      Calls the function FUNC with each the members of the collection.
  784.      Returns self.
  785.  
  786.  - Method on Collection: (void*) -newEnumState
  787.  
  788.  - Method on Collection:  -freeEnumState: (void**)ENUMSTATEPTR
  789.  
  790.  - Method on Collection: (BOOL) -getNextObject: (id *)ANOBJECTPTR
  791.           withEnumState: (void**)ENUMSTATE
  792.  - Method on Collection: (BOOL) -getNextElement: (elt *)ANELEMENTPTR
  793.           withEnumState: (void**)ENUMSTATE
  794.  
  795.      void print_first_difference (id coll1, id coll2)
  796.        {
  797.          void *enumState1, *enumState2;
  798.          id object1, object2;
  799.      
  800.          enumState1 = [coll1 newEnumState];
  801.          enumState2 = [coll2 newEnumState];
  802.          while ([coll1 getNextObject:&object1 withEnumState:&enumState1]
  803.                 && [coll2 getNextObject:&object2 withEnumState:&enumState2])
  804.            {
  805.              if ([object1 compare:object2])
  806.                {
  807.                  [object1 printForDebugger];
  808.                  [object2 printForDebugger];
  809.                }
  810.            }
  811.          [coll1 freeEnumState:&enumState1];
  812.          [coll2 freeEnumState:&enumState2];
  813.        }
  814.  
  815.  - Method on Collection:  -withElementsCall: (void(*)(elt))AFUNC
  816.           whileTrue: (BOOL*)FLAG
  817.  - Method on Collection:  -safeWithElementsCall: (void(*)(elt))AFUNC
  818.           whileTrue: (BOOL*)FLAG
  819.  
  821. File: libobjects.info,  Node: Keyed Enumerating,  Next: Indexed Enumerating,  Prev: Basic Enumerating,  Up: Enumerating
  822.  
  823. Keyed Enumerating
  824. =================
  825.  
  827. File: libobjects.info,  Node: Indexed Enumerating,  Next: LAMBDA,  Prev: Keyed Enumerating,  Up: Enumerating
  828.  
  829. Indexed Enumerating
  830. ===================
  831.  
  832.  - Method on IndexedCollection: (BOOL) -getPrevObject: (id *)
  833.           ANOBJECTPTR withEnumState: (void**)ENUMSTATE
  834.  - Method on IndexedCollection: (BOOL) -getPrevElement: (elt *)
  835.           ANELEMENTPTR withEnumState: (void**)ENUMSTATE
  836.  
  837.  - Method on IndexedCollection:  -withObjectsInReverseCall:
  838.           (void(*)(id))AFUNC
  839.  - Method on IndexedCollection:  -safeWithObjectsInReverseCall:
  840.           (void(*)(id))AFUNC
  841.  - Method on IndexedCollection:  -withElementsInReverseCall:
  842.           (void(*)(elt))AFUNC
  843.  - Method on IndexedCollection:  -safeWithElementsInReverseCall:
  844.           (void(*)(elt))AFUNC
  845.  
  846.  - Method on IndexedCollection:  -withObjectsInReverseCall:
  847.           (void(*)(id)) AFUNC whileTrue: (BOOL *)FLAG
  848.  - Method on IndexedCollection:  -safeWithObjectsInReverseCall:
  849.           (void(*)(id)) AFUNC whileTrue: (BOOL *)FLAG
  850.  - Method on IndexedCollection:  -withElementsInReverseCall:
  851.           (void(*)(elt)) AFUNC whileTrue: (BOOL *)FLAG
  852.  - Method on IndexedCollection:  -safeWithElementsInReverseCall:
  853.           (void(*)(elt)) AFUNC whileTrue: (BOOL *)FLAG
  854.  
  855.  - Method on IndexedCollection:  -makeObjectsPerformInReverse: (SEL)
  856.           ASEL
  857.  - Method on IndexedCollection:  -safeMakeObjectsPerformInReverse:
  858.           (SEL) ASEL
  859.  - Method on IndexedCollection:  -makeObjectsPerformInReverse: (SEL)
  860.           ASEL with: ARGOBJECT
  861.  - Method on IndexedCollection:  -safeMakeObjectsPerformInReverse:
  862.           (SEL) ASEL with: ARGOBJECT
  863.  
  865. File: libobjects.info,  Node: LAMBDA,  Prev: Indexed Enumerating,  Up: Enumerating
  866.  
  867. Defining Functions In Place with LAMBDA()
  868. =========================================
  869.  
  870.    NOTE:  The LAMBDA macro does not work on all systems.  We are waiting
  871. for a general fix.  You should avoid using it until then.
  872.  
  873.    There may not already be a function that does the operation you want
  874. performed during an enumeration.  In this case you will have to write
  875. such a function yourself.
  876.  
  877.    If the function will be used more than once, you should write it as C
  878. functions are usually defined.  However, if the function will only be
  879. used for this one enumeration and the function is small, using the
  880. `LAMBDA' macro may be easier and more clear.
  881.  
  882.  - Macro: LAMBDA(RETTYPE, ARGS, BODY)
  883.      `LAMBDA' is a macro for defining a nested function and returning a
  884.      pointer to that function.  You can use `LAMBDA' wherever a
  885.      function pointer is required.  RETTYPE is the C type returned by
  886.      the function.  ARGS is the parenthesis-enclosed list of arguments
  887.      to the function.  (Declare them just like in an ANSI function
  888.      definition.)  BODY is the curly-bracket-enclosed body of the
  889.      function.
  890.  
  891.      For example, you could create a pointer to a function that adds its
  892.      arguments like this:
  893.           LAMBDA(int, (int a, int b), {return a + b;})
  894.  
  895.    `LAMBDA' is particularly convenient for enumeration methods because
  896. the macro can be placed in the position of the method argument.  For
  897. instance, you can write:
  898.        - fooMethod
  899.        {
  900.          id newColl;
  901.          ...
  902.          newColl = [self emptyCopyAs:[Array class]];
  903.          [self withObjectsCall:
  904.                LAMBDA(void, (id o), {[newColl addObject:[o copy]];})];
  905.          return self;
  906.        }
  907.    instead of writing:
  908.        - fooMethod
  909.        {
  910.          id newColl = [self emptyCopyAs:[Array class]];
  911.          void myTmpFunc(id o)
  912.            {
  913.              [newColl addObject:[o copy]];
  914.            }
  915.          ...
  916.          [self withObjectsCall:myTmpFunc];
  917.          return self;
  918.        }
  919.    In these examples, there may be many lines of code between the
  920. declarations at the top of the method and the `withObjectsCall:' at the
  921. bottom of the method.  Using `LAMBDA' allows you to declare the
  922. function where it is used, instead of arbitrarily far from where it is
  923. used.
  924.  
  925.    The name `LAMBDA' comes from lambda calculus and LISP.
  926.  
  927.    The `LAMBDA' macro and some similar macros are defined in
  928. `coll/collstd.h'.
  929.  
  930. Filtered Enumerating
  931. ====================
  932.  
  933. Enumerating with Keyed Collections
  934. ==================================
  935.  
  936. Enumerating with Indexed Collections
  937. ====================================
  938.  
  939.    <<This section unfinished.>>
  940.  
  942. File: libobjects.info,  Node: Duplicating,  Next: Archiving,  Prev: Enumerating,  Up: Top
  943.  
  944. Duplicating
  945. ***********
  946.  
  947.    Talk about shallow and deep copies.
  948.  
  949.    <<This section unfinished.>>
  950.  
  952. File: libobjects.info,  Node: Archiving,  Next: Querying,  Prev: Duplicating,  Up: Top
  953.  
  954. Archiving
  955. *********
  956.  
  957.    You can write collections to a stream.  You can read them back in
  958. again.  Talk about the `-awake' method.
  959.  
  960.  - Method on Collection:  -write: (TypedStream*)ASTREAM
  961.      <<Undocumented>>  Returns self.
  962.  
  963.  - Method on Collection:  -read: (TypedStream*)ASTREAM
  964.      <<Undocumented>>  Returns self.
  965.  
  966.    <<This section unfinished.>>
  967.  
  969. File: libobjects.info,  Node: Querying,  Next: Sorting,  Prev: Archiving,  Up: Top
  970.  
  971. Querying
  972. ********
  973.  
  974.    <<This section unfinished.>>
  975.  
  976. * Menu:
  977.  
  978. * Basic Querying::
  979. * Keyed Querying::
  980. * Indexed Querying::
  981.  
  983. File: libobjects.info,  Node: Basic Querying,  Next: Keyed Querying,  Up: Querying
  984.  
  985. Basic Querying
  986. ==============
  987.  
  988.  - Method on Collection: (BOOL) -isEmpty
  989.      Returns YES if the receiver contains no members; returns NO
  990.      otherwise.
  991.  
  992.  - Method on Collection: (const char *) -contentEncoding
  993.      Returns a description of the C type that the receiving collection
  994.      can hold.  The description is a string of the form returned by the
  995.      Objective-C `@encode' directive.
  996.  
  998. File: libobjects.info,  Node: Keyed Querying,  Next: Indexed Querying,  Prev: Basic Querying,  Up: Querying
  999.  
  1000. Keyed Querying
  1001. ==============
  1002.  
  1004. File: libobjects.info,  Node: Indexed Querying,  Prev: Keyed Querying,  Up: Querying
  1005.  
  1006. Indexed Querying
  1007. ================
  1008.  
  1010. File: libobjects.info,  Node: Sorting,  Next: Classes,  Prev: Querying,  Up: Top
  1011.  
  1012. Sorting
  1013. *******
  1014.  
  1015.    <<This section unfinished.>>
  1016.  
  1018. File: libobjects.info,  Node: Classes,  Next: Projects,  Prev: Sorting,  Up: Top
  1019.  
  1020. Choosing the Right Class
  1021. ************************
  1022.  
  1023.    Talk about keys or no keys, ordered or not ordered.  Talk about the
  1024. classes the require protocol-conforming objects as members.
  1025.  
  1026. * Menu:
  1027.  
  1028. * Set::
  1029. * Bag::
  1030.  
  1031. * Dictionary::
  1032. * MappedCollector::
  1033.  
  1034. * Array::
  1035. * Stack::
  1036. * Queue::
  1037. * GapArray::
  1038.  
  1039. * LinkedList::
  1040. * BinaryTree::
  1041. * RBTree::
  1042. * SplayTree::
  1043. * EltNodeCollector::
  1044.  
  1045. * Collection::
  1046. * KeyedCollection::
  1047. * IndexedCollection::
  1048.  
  1049.    <<This section unfinished.>>
  1050.  
  1052. File: libobjects.info,  Node: Set,  Next: Bag,  Up: Classes
  1053.  
  1054. Set
  1055. ===
  1056.  
  1057.    <<This section unfinished.>>
  1058.  
  1060. File: libobjects.info,  Node: Bag,  Next: Dictionary,  Prev: Set,  Up: Classes
  1061.  
  1062. Bag
  1063. ===
  1064.  
  1065.    A Bag is ...
  1066.  
  1067. * Menu:
  1068.  
  1069. * Basic Creating::
  1070. * Freeing::
  1071. * Bag Adding::
  1072. * Basic Adding::
  1073. * Keyed Adding::
  1074. * Indexed Adding::
  1075. * Bag Removing::
  1076. * Basic Removing::
  1077. * Keyed Removing::
  1078. * Indexed Removing::
  1079. * Basic Removing::
  1080. * Keyed Removing::
  1081. * Indexed Removing::
  1082. * Basic Enumerating::
  1083. * Keyed Enumerating::
  1084. * Indexed Enumerating::
  1085.  
  1087. File: libobjects.info,  Node: Bag Adding,  Next: Bag Removing,  Up: Bag
  1088.  
  1089.  - Method on Bag:  -addObject: NEWOBJECT withOccurrences:
  1090.           (unsigned)COUNT
  1091.  - Method on Bag:  -addElement: (elt)NEWELEMENT withOccurrences:
  1092.           (unsigned)COUNT
  1093.  
  1095. File: libobjects.info,  Node: Bag Removing,  Prev: Bag Adding,  Up: Bag
  1096.  
  1097.  - Method on Bag:  -removeObject: OLDOBJECT occurrences: (unsigned)COUNT
  1098.  - Method on Bag:  -removeElement: (elt)OLDELEMENT occurrences:
  1099.           (unsigned)COUNT
  1100.  
  1101.    <<This section unfinished.>>
  1102.  
  1104. File: libobjects.info,  Node: Dictionary,  Next: MappedCollector,  Prev: Bag,  Up: Classes
  1105.  
  1106. Dictionary
  1107. ==========
  1108.  
  1109.    A Dictionary is ...
  1110.  
  1112. File: libobjects.info,  Node: MappedCollector,  Next: Array,  Prev: Dictionary,  Up: Classes
  1113.  
  1114. MappedCollector
  1115. ===============
  1116.  
  1117.    A MappedCollector is ...
  1118.  
  1120. File: libobjects.info,  Node: Array,  Next: Stack,  Prev: MappedCollector,  Up: Classes
  1121.  
  1122. Array
  1123. =====
  1124.  
  1125.    An Array is ...
  1126.  
  1127. * Menu:
  1128.  
  1129. * Array Capacity Management::
  1130. * Basic Creating::
  1131. * Freeing::
  1132. * Basic Adding::
  1133. * Keyed Adding::
  1134. * Indexed Adding::
  1135. * Basic Removing::
  1136. * Keyed Removing::
  1137. * Indexed Removing::
  1138. * Basic Replacing::
  1139. * Keyed Replacing::
  1140. * Indexed Replacing::
  1141. * Basic Enumerating::
  1142. * Keyed Enumerating::
  1143. * Indexed Enumerating::
  1144. * Duplicating::
  1145. * Archiving::
  1146. * Basic Querying::
  1147. * Keyed Querying::
  1148. * Indexed Querying::
  1149.  
  1151. File: libobjects.info,  Node: Array Capacity Management,  Up: Array
  1152.  
  1153. Array Methods
  1154. =============
  1155.  
  1156.  - Method on Array: (unsigned) +defaultCapacity
  1157.  
  1158.  - Method on Array: (unsigned) +defaultGrowFactor
  1159.  
  1160.  - Method on Array:  -initEncoding: (const char *)
  1161.      CONTENTENCODING capacity: (unsigned) ACAPACITY
  1162.  
  1163.  
  1164.  - Method on Array:  -setCapacity: (unsigned) NEWCAPACITY
  1165.  
  1166.  - Method on Array:  -setGrowFactor: (unsigned) ANUM
  1167.  
  1169. File: libobjects.info,  Node: Stack,  Next: Queue,  Prev: Array,  Up: Classes
  1170.  
  1171. Stack
  1172. =====
  1173.  
  1174. * Menu:
  1175.  
  1176. * Stack Methods::
  1177. * Array Capacity Management::
  1178. * Basic Creating::
  1179. * Freeing::
  1180. * Basic Adding::
  1181. * Keyed Adding::
  1182. * Indexed Adding::
  1183. * Basic Removing::
  1184. * Keyed Removing::
  1185. * Indexed Removing::
  1186. * Basic Replacing::
  1187. * Keyed Replacing::
  1188. * Indexed Replacing::
  1189. * Basic Enumerating::
  1190. * Keyed Enumerating::
  1191. * Indexed Enumerating::
  1192. * Duplicating::
  1193. * Archiving::
  1194. * Basic Querying::
  1195. * Keyed Querying::
  1196. * Indexed Querying::
  1197.  
  1199. File: libobjects.info,  Node: Stack Methods,  Up: Stack
  1200.  
  1201.  - Method on Stack:  -pushObject: NEWOBJECT
  1202.  - Method on Stack:  -pushElement: (elt)NEWELEMENT
  1203.  
  1204.  - Method on Stack:  -popObject: NEWOBJECT
  1205.  - Method on Stack:  -popElement: (elt)NEWELEMENT
  1206.  
  1207.  - Method on Stack:  -topObject
  1208.  - Method on Stack: (elt) -topElement
  1209.  
  1210.  - Method on Stack:  -exchangeTop
  1211.  
  1213. File: libobjects.info,  Node: Queue,  Next: GapArray,  Prev: Stack,  Up: Classes
  1214.  
  1216. File: libobjects.info,  Node: GapArray,  Next: LinkedList,  Prev: Queue,  Up: Classes
  1217.  
  1219. File: libobjects.info,  Node: LinkedList,  Next: BinaryTree,  Prev: GapArray,  Up: Classes
  1220.  
  1222. File: libobjects.info,  Node: BinaryTree,  Next: RBTree,  Prev: LinkedList,  Up: Classes
  1223.  
  1225. File: libobjects.info,  Node: RBTree,  Next: SplayTree,  Prev: BinaryTree,  Up: Classes
  1226.  
  1228. File: libobjects.info,  Node: SplayTree,  Next: EltNodeCollector,  Prev: RBTree,  Up: Classes
  1229.  
  1231. File: libobjects.info,  Node: EltNodeCollector,  Next: Collection,  Prev: SplayTree,  Up: Classes
  1232.  
  1234. File: libobjects.info,  Node: Collection,  Next: KeyedCollection,  Prev: EltNodeCollector,  Up: Classes
  1235.  
  1236.    A Collection is ...
  1237.  
  1238. * Menu:
  1239.  
  1240. * Basic Creating::
  1241. * Freeing::
  1242. * Basic Adding::
  1243. * Basic Removing::
  1244. * Basic Replacing::
  1245. * Basic Enumerating::
  1246. * Duplicating::
  1247. * Archiving::
  1248. * Basic Querying::
  1249.  
  1251. File: libobjects.info,  Node: KeyedCollection,  Next: IndexedCollection,  Prev: Collection,  Up: Classes
  1252.  
  1253. KeyedCollection
  1254. ===============
  1255.  
  1256. * Menu:
  1257.  
  1258. * Basic Creating::
  1259. * Keyed Creating::
  1260. * Freeing::
  1261. * Basic Adding::
  1262. * Keyed Adding::
  1263. * Basic Removing::
  1264. * Keyed Removing::
  1265. * Basic Replacing::
  1266. * Keyed Replacing::
  1267. * Basic Enumerating::
  1268. * Keyed Enumerating::
  1269. * Duplicating::
  1270. * Archiving::
  1271. * Basic Querying::
  1272. * Keyed Querying::
  1273.  
  1275. File: libobjects.info,  Node: IndexedCollection,  Prev: KeyedCollection,  Up: Classes
  1276.  
  1277. IndexedCollection
  1278. =================
  1279.  
  1280. * Menu:
  1281.  
  1282. * Basic Creating::
  1283. * Freeing::
  1284. * Basic Adding::
  1285. * Keyed Adding::
  1286. * Indexed Adding::
  1287. * Basic Removing::
  1288. * Keyed Removing::
  1289. * Indexed Removing::
  1290. * Basic Replacing::
  1291. * Keyed Replacing::
  1292. * Indexed Replacing::
  1293. * Basic Enumerating::
  1294. * Keyed Enumerating::
  1295. * Indexed Enumerating::
  1296. * Duplicating::
  1297. * Archiving::
  1298. * Basic Querying::
  1299. * Keyed Querying::
  1300. * Indexed Querying::
  1301.  
  1303. File: libobjects.info,  Node: Projects,  Next: Protocol Index,  Prev: Classes,  Up: Top
  1304.  
  1305. To Do List and Questions
  1306. ************************
  1307.  
  1308. Projects Looking for Volunteers
  1309. ===============================
  1310.  
  1311.    If you think you can do one of these projects, please let me know.
  1312. Your help is greatly appreciated!  Send email to
  1313. `mccallum@gnu.ai.mit.edu'.
  1314.  
  1315.    * Make the GNU Objective C runtime properly initialize the class
  1316.      pointer of statically-created string objects (i.e. the string
  1317.      objects created with the syntax `@"This is a constant string
  1318.      object"').  See the relevant comments in gcc/objc-act.c.  Once we
  1319.      get this working I'll release the suite of String classes that
  1320.      I've already written.
  1321.  
  1322.      Please!  Someone?  I want to do this soon so that we can get the
  1323.      ensuing interface changes done before too many people write code
  1324.      based on the current deprecated char-pointer interfaces.
  1325.  
  1326.    * Make the GNU Objective C runtime thread-safe.  (Again, someone?
  1327.      We really need this.)
  1328.  
  1329.    * Write a test-suite for the library.  Use dejagnu.
  1330.  
  1331.    * Write a proper name server for SocketPort's.  Currently we're just
  1332.      hashing the name to a socket port number--we could get unwanted
  1333.      hash collisions.  This will also allow us to name a SocketPort
  1334.      after it's been created.
  1335.  
  1336.    * Make SocketPort more reliable than UDP.
  1337.  
  1338.    * Add some features to the compiler:
  1339.        1. You can't add __attribute__'s to methods.  I want to use:
  1340.                   - (int) writeFormat: (const char *)format, ...
  1341.                       __attribute__ ((format (printf, 1, 2)));
  1342.                   - (int) readFormat: (const char *)format, ...
  1343.                       __attribute__ ((format (scanf, 1, 2)));
  1344.  
  1345.        2. I would like to be able to use a function name/pointer as an
  1346.           argument to @encode() and get a type string like the selector
  1347.           types.
  1348.  
  1349.    * Notification registration classes, notification classes.
  1350.  
  1351.    * Write more/better random number generators.  Make them conform to
  1352.      the protocol <RandomGenerating>.  See RNGAdditiveCongruential.
  1353.  
  1354.    * Write user-visible random number classes in the spirit of the
  1355.      `Random' class.  Look at Smalltalk's ProbabilityDistribution
  1356.      classes, and think about replacing the `Random' class with
  1357.      something more like these.  How about Poisson and Gaussian
  1358.      distributions also?
  1359.  
  1360. My To Do's
  1361. ==========
  1362.  
  1363.    * Many code fixes and cleanups, indicated with `xxx' in the source.
  1364.  
  1365.    * In remote object messaging, send exceptions back to the requestor.
  1366.      I'm waiting for gcc 2.7 exceptions.
  1367.  
  1368.    * Add Coding methods to all the other collection classes.
  1369.  
  1370.    * Find method for detecting NeXT vs GNU runtime.  Put it in
  1371.      `configure.in' and define `NeXT_runtime'.
  1372.  
  1373.    * The LAMBDA macro doesn't work on all systems.  Request a change to
  1374.      gcc that make something like LAMBDA work on all systems.
  1375.  
  1376.    * Possibly change `-(int)compare:anObject' for Collection.  How
  1377.      should non-Indexed collections be ordered?
  1378.  
  1379.    * Think about restructuring the Collection heirarchy.  We need an
  1380.      abstract class for collections that are ordered, but whose order
  1381.      is fixed by the -compare: method, i.e. not user-settable.  We need
  1382.      non-mutable version of the classes.  The implementation of this
  1383.      stuff is crying out for multiple inheritance or
  1384.      protocols-with-implementation!
  1385.  
  1386.    * Finish HashTable.m.  Implement freeKeys:values: (What is this
  1387.      supposed to do anyway?).  Handle archiving of atom string, "%",
  1388.      keys.
  1389.  
  1390.    * Finish Time.m.  Many methods are not yet implemented.
  1391.  
  1392.    * Write a good hash function for floats and doubles.
  1393.  
  1394.    * Many implementations could be made more efficient.  Libobjects
  1395.      hasn't been efficiency tuned at all.  Overridding more methods in
  1396.      certain classes could make things more efficient (especially
  1397.      EltNodeCollector).  SplayTree's could be done using top-down
  1398.      splaying.  collhash could be completely reimplemented.  ...and a
  1399.      lot more...
  1400.  
  1401.    * Fix bugs that arise when double's are included in the elt union.
  1402.  
  1403.    * Fix all the subclassResponsibility comments in objects/*.h
  1404.  
  1405.    * I will finish libobjects documentation.
  1406.  
  1407. Questions
  1408. =========
  1409.  
  1410.    I would greatly appreciate your feedback on the questions below.
  1411. Please email your thoughts to mccallum@gnu.ai.mit.edu.
  1412.  
  1413.    * I want to put method names in texinfo indices, but the colons in
  1414.      the method names are interfering with info's notion of menu item
  1415.      names and node names.  Help.  Any ideas?  (Kresten?)
  1416.  
  1417.    * I need to read through al the enumState code again and clean it up.
  1418.      Perhaps we'd like an Iterator class to use as a wrapper around the
  1419.      enumState functionality?  The NIH Class Library organizes things
  1420.      this way.
  1421.  
  1422.    * Should we keep the -safe... enumeration methods?  They sure do add
  1423.      a lot of clutter to the protocols.  If we got rid of them people
  1424.      would have to alloc an Array, copy the contents, and free the Array
  1425.      themselves.
  1426.  
  1427.    * What would people think about removing the ...Object methods, and
  1428.      just having the ...Element methods instead?  It might be a bit
  1429.      more difficult to use, but it would reduce clutter significantly.
  1430.      The ...Element methods are more efficient to use anyway, since
  1431.      most ...Object methods are wrappers around ...Element calls.  I'm
  1432.      not sure what I think we should do.
  1433.  
  1434.      Here's an idea: Define the ...Object methods as macros.  But we
  1435.      need a new macro scheme that works for methods instead of
  1436.      functions.  We would need something with the following
  1437.      functionality:
  1438.           #define [REC replaceObject: OLDOBJ with: NEWOBJ] \
  1439.                   ([REC replaceElement:(elt)(OLDOBJ) with:(elt)(NEWOBJ)].id_u)
  1440.      The issue of macros for methods has been mentioned in email found
  1441.      in the gnu-objc-issues archive, in the file `preprocessor'.
  1442.  
  1443.    * It would be nice to have more error checking on the types going in
  1444.      and out of a collection.  When some code tries to put a float into
  1445.      a collector initialized to hold integers, it would be nice to
  1446.      catch that.  Perhaps just some macros that will do the appropriate
  1447.      checks?  It would also be nice if elt's returned from methods were
  1448.      automatically casted to the correct type.
  1449.  
  1450.      It might be good to use something like this (from the gcc PROJECTS
  1451.      file):
  1452.           * A way of defining a structure containing a union, in which the choice
  1453.           of union alternative is controlled by a previous structure component.
  1454.           
  1455.           Here is a possible syntax for this.
  1456.           
  1457.           struct foo {
  1458.             enum { INT, DOUBLE } code;
  1459.             auto union { case INT: int i; case DOUBLE: double d;} value : code;
  1460.           };
  1461.  
  1462.      This has the disadvantage that now elt's will take up more than one
  1463.      word.
  1464.  
  1465.      What I would prefer is something more radical:  Some efficient way
  1466.      to enable int's, float's to receive Objective-C messages.  Then I
  1467.      wouldn't have to worry about any of these horrible elt typing
  1468.      issues; I wouldn't have to worry about all the ...Object
  1469.      ...Element method name duplication; I wouldn't have to worry about
  1470.      the inefficiency of having all the ...Object methods just be
  1471.      covers for the ...Element methods.  Lots of other Objective-C code
  1472.      would find this useful too.  It has the advantage of fixing the
  1473.      previous question also (about removing the ...Element ...Object
  1474.      method duplication).  We need Objective-C objects that can live on
  1475.      the stack.
  1476.  
  1477.      For now, I've worked out a ObjC++ solution to this with
  1478.      constructors and casting operators.  Now I'm just waiting for
  1479.      Kresten to finish ObjC++.
  1480.  
  1481.    * Perhaps we should put more safety checks into LinkedList,
  1482.      BinaryTree, etc:  Check that node is not already part of another
  1483.      collection (by checking that neighbor pointers are nil?)  In method
  1484.      "insertObject:newObject after:oldObject" make sure that oldObject
  1485.      is a member of self.  ...It seems that there is a lot of potential
  1486.      for nasty bugs with mistakes like these.
  1487.  
  1488.    * HashTable.m (-initKeyDesc:valueDesc:capacity:)  I tried to make it
  1489.      portable, but I didn't try very hard.  Anyone want to send in
  1490.      fixes?
  1491.  
  1492.    * I fixed -emptyCopy in all the subclasses, but the -emptyCopy scheme
  1493.      seems pretty fragile.  How about calling -initFoo: inside
  1494.      -emptyCopy?  This way we avoid having yet another method in which
  1495.      instance vars must be initialized to some consistent state.
  1496.      -allocCopy would never even get called.  <<ObjC insiders: This is
  1497.      a less well-expressed version of what we've just been discussing
  1498.      in email.>>
  1499.  
  1500.    * The situation with LinkedListNode and LinkedListEltNode, (and the
  1501.      analagous classes for BinaryTree's and RBTree's) are just crying
  1502.      out for multiple inheritance.  Anyone have ideas that are prettier
  1503.      than my quick fix using #include ?  Anyone have an alternate
  1504.      organization that doesn't need multiple inheritance?
  1505.  
  1506.    * Somes classes, like RBTree, depend on a certain ordering of
  1507.      elements to maintain internal consistency.  How should we define
  1508.      the behavior of methods whose names imply that the user can set
  1509.      the ordering of elements independent of these constraints? (like
  1510.      -appendElement: or -insertElement:atIndex: for instance).  I see
  1511.      three possibilities:
  1512.        1. The methods do what they say.  Give the user the power to
  1513.           override the default ordering.
  1514.  
  1515.        2. The methods do not do what they say, but call addElement:
  1516.           instead.  This lets the class maintain its internal
  1517.           consistency, but it has the potential to be a bit confusing
  1518.           to the user.  What would happen if the user sent a sort
  1519.           message to such a class, for instance?
  1520.  
  1521.        3. The methods trigger a -shouldNotImplement: error.  This
  1522.           solution perhaps best expresses the reality of the situation,
  1523.           but it's a bit strange for a class to signal an error on a
  1524.           method which is in a protocol the class conforms to.
  1525.             Currently I'm using solution #1 (in most classes?).
  1526.  
  1527.    * I created libobjects.texi by copying libg++.texi.  Some of the text
  1528.      is taken verbatim.  Is this a problem?
  1529.  
  1530.    * If you don't like the organization of the documentation and you
  1531.      have suggestions for changes, please say so now, not after it's
  1532.      all been written.
  1533.  
  1534.    * Does anyone really miss the ability to set the comparison function
  1535.      independent of the element encoding?  If it's really important we
  1536.      can come up with ways to do this and still be able to archive
  1537.      comparison functions.
  1538.  
  1539.    * Something like this needed?  - elementDidChange: (elt*)elementPtr;
  1540.      Currently you have to remove, change, add, for some classes.
  1541.  
  1542.    * Opinions on the error reporting scheme?  See also
  1543.      `checks/test05.m'.  This error reporting scheme will most likely
  1544.      change completely as soon as gcc gets exception handling.
  1545.  
  1546.    * Should I include _comparison_function as an instance variable of
  1547.      Collection?  Putting it back in could make some things more
  1548.      efficient, but several classes don't have configurable
  1549.      comparisonFunction's (i.e. String, LinkedList, BinaryTree,
  1550.      RBTree), so they don't need it.
  1551.  
  1552.    * I've been told that GNU filenames should be 14 chars or less.  I
  1553.      don't want to abbreviate my classnames, but I think using .h
  1554.      @interface files with names different than the class name is even
  1555.      worse.  ** I want to keep my unabbreviated filenames!! **  What to
  1556.      do, what to do... I can't believe that *all* GNU classnames will be
  1557.      limited to 12 characters forever and ever--disgusting.
  1558.  
  1559. Changes I'd like in the Objective-C runtime and gcc:
  1560. ====================================================
  1561.  
  1562.    * Make OBJC_MALLOC() and friends public.  Have the runtime and
  1563.      Object.m use them.  See objc-malloc.[hm].
  1564.  
  1565.    * Give hash.[hc] functionality more like collhash.[hc], i.e.: Add
  1566.      hash_node_for_key() to hash.h and hash.c.  Change hash_next() so
  1567.      that more than one enumeration of the contents can happen
  1568.      concurrently.  How about removing cache as a parameter to the
  1569.      hashing functions in hash.h and hash.c.  Do the masking on the
  1570.      result of the hash function.  This seems much neater to me.
  1571.  
  1572.    * Add a way of defining a structure containing a union, in which the
  1573.      choice of union alternative is controlled by a previous structure
  1574.      component.  (See gcc `PROJECTS' file.)
  1575.  
  1576. How to contribute
  1577. =================
  1578.  
  1579.    Programmers who have written Objective-C classes that they believe
  1580. to be of general interest are encouraged to write to
  1581. mccallum@gnu.ai.mit.edu.  Contributing code is not difficult. Here are
  1582. some general guidelines:
  1583.  
  1584.    * FSF must maintain the right to accept or reject potential
  1585.      contributions.  Generally, the only reasons for rejecting
  1586.      contributions are cases where they duplicate existing or
  1587.      nearly-released code, contain unremovable specific machine
  1588.      dependencies, or are somehow incompatible with the rest of the
  1589.      library.
  1590.  
  1591.    * Acceptance of contributions means that the code is accepted for
  1592.      adaptation into libobjects.  FSF must reserve the right to make
  1593.      various editorial changes in code. Very often, this merely entails
  1594.      formatting, maintenance of various conventions, etc. Contributors
  1595.      are always given authorship credit and shown the final version for
  1596.      approval.
  1597.  
  1598.    * Contributors must assign their copyright to FSF via a form sent out
  1599.      upon acceptance. Assigning copyright to FSF ensures that the code
  1600.      may be freely distributed.
  1601.  
  1602.    * Assistance in providing documentation, test files, and debugging
  1603.      support is strongly encouraged.
  1604.  
  1605.    Extensions, comments, and suggested modifications of existing
  1606. libobjects features are also very welcome.
  1607.  
  1609. File: libobjects.info,  Node: Protocol Index,  Next: Class Index,  Prev: Projects,  Up: Top
  1610.  
  1611. Protocol Index
  1612. **************
  1613.  
  1614. * Menu:
  1616. File: libobjects.info,  Node: Class Index,  Next: Method Function Macro Index,  Prev: Protocol Index,  Up: Top
  1617.  
  1618. Class Index
  1619. ***********
  1620.  
  1621. * Menu:
  1623. File: libobjects.info,  Node: Method Function Macro Index,  Next: Concept Index,  Prev: Class Index,  Up: Top
  1624.  
  1625. Method, Function and Macro Index
  1626. ********************************
  1627.  
  1628. * Menu:
  1629.  
  1630. * -exchangeTop on Stack:                Stack Methods.
  1631. * -freeEnumState: on Collection:        Basic Enumerating.
  1632. * -getNextElement:withEnumState: on Collection: Basic Enumerating.
  1633. * -getNextObject:withEnumState: on Collection: Basic Enumerating.
  1634. * -getPrevElement:withEnumState: on IndexedCollection: Indexed Enumerating.
  1635. * -getPrevObject:withEnumState: on IndexedCollection: Indexed Enumerating.
  1636. * -makeObjectsPerformInReverse: on IndexedCollection: Indexed Enumerating.
  1637. * -makeObjectsPerformInReverse:with: on IndexedCollection: Indexed Enumerating.
  1638. * -newEnumState on Collection:          Basic Enumerating.
  1639. * -popElement: on Stack:                Stack Methods.
  1640. * -popObject: on Stack:                 Stack Methods.
  1641. * -pushElement: on Stack:               Stack Methods.
  1642. * -pushObject: on Stack:                Stack Methods.
  1643. * -safeMakeObjectsPerformInReverse: on IndexedCollection: Indexed Enumerating.
  1644. * -safeMakeObjectsPerformInReverse:with: on IndexedCollection: Indexed Enumerating.
  1645. * -safeWithElementsCall:whileTrue: on Collection: Basic Enumerating.
  1646. * -safeWithElementsInReverseCall: on IndexedCollection: Indexed Enumerating.
  1647. * -safeWithElementsInReverseCall:whileTrue: on IndexedCollection: Indexed Enumerating.
  1648. * -safeWithObjectsInReverseCall: on IndexedCollection: Indexed Enumerating.
  1649. * -safeWithObjectsInReverseCall:whileTrue: on IndexedCollection: Indexed Enumerating.
  1650. * -setCapacity: on Array:               Array Capacity Management.
  1651. * -setGrowFactor: on Array:             Array Capacity Management.
  1652. * -topElement on Stack:                 Stack Methods.
  1653. * -topObject on Stack:                  Stack Methods.
  1654. * -withElementsCall:whileTrue: on Collection: Basic Enumerating.
  1655. * -withElementsInReverseCall: on IndexedCollection: Indexed Enumerating.
  1656. * -withElementsInReverseCall:whileTrue: on IndexedCollection: Indexed Enumerating.
  1657. * -withObjectsInReverseCall: on IndexedCollection: Indexed Enumerating.
  1658. * -withObjectsInReverseCall:whileTrue: on IndexedCollection: Indexed Enumerating.
  1659. * +defaultCapacity on Array:            Array Capacity Management.
  1660. * +defaultGrowFactor on Array:          Array Capacity Management.
  1661. * -addContentsOf: on Collection:        Basic Adding.
  1662. * -addContentsOfIfAbsent: on Collection: Basic Adding.
  1663. * -addElement: on Bag:                  Bag Adding.
  1664. * -addElement: on Collection:           Basic Adding.
  1665. * -addElementIfAbsent: on Collection:   Basic Adding.
  1666. * -addElementsCount: on Collection:     Basic Adding.
  1667. * -addObject: on Bag:                   Bag Adding.
  1668. * -addObject: on Collection:            Basic Adding.
  1669. * -addObjectIfAbsent: on Collection:    Basic Adding.
  1670. * -addObjectsCount: on Collection:      Basic Adding.
  1671. * -appendContentsOf: on IndexedCollection: Indexed Adding.
  1672. * -appendElement: on IndexedCollecting: Indexed Adding.
  1673. * -appendObject: on IndexedCollection:  Indexed Adding.
  1674. * -contentEncoding on Collection:       Basic Querying.
  1675. * -initEncoding: on Array:              Array Capacity Management.
  1676. * -initEncoding: on Collection:         Basic Creating.
  1677. * -init on Collection:                  Basic Creating.
  1678. * -insertElement:after: on IndexedCollecting: Indexed Adding.
  1679. * -insertElement:atIndex: on IndexedCollecting: Indexed Adding.
  1680. * -insertElement:atKey: on KeyedCollection: Keyed Adding.
  1681. * -insertElement:before: on IndexedCollecting: Indexed Adding.
  1682. * -insertObject:after: on IndexedCollection: Indexed Adding.
  1683. * -insertObject:atIndex: on IndexedCollection: Indexed Adding.
  1684. * -insertObject:atKey: on KeyedCollection: Keyed Adding.
  1685. * -insertObject:before: on IndexedCollection: Indexed Adding.
  1686. * -isEmpty on Collection:               Basic Querying.
  1687. * -prependContentsOf: on IndexedCollection: Indexed Adding.
  1688. * -prependElement: on IndexedCollecting: Indexed Adding.
  1689. * -prependObject: on IndexedCollection: Indexed Adding.
  1690. * -read: on Collection:                 Archiving.
  1691. * -removeElement: on Bag:               Bag Removing.
  1692. * -removeObject: on Bag:                Bag Removing.
  1693. * -safeWithElementsCall: on Collection: Basic Enumerating.
  1694. * -safeWithObjectsCall: on Collection:  Basic Enumerating.
  1695. * -withElementsCall: on Collection:     Basic Enumerating.
  1696. * -withObjectsCall: on Collection:      Basic Enumerating.
  1697. * -write: on Collection:                Archiving.
  1698. * insertContentsOf:atIndex: on IndexedCollection: Indexed Adding.
  1699. * COLL_GCC_VERSION:                     Conventions.
  1700. * COLL_VERSION:                         Conventions.
  1701. * LAMBDA:                               LAMBDA.
  1702.  
  1704. File: libobjects.info,  Node: Concept Index,  Prev: Method Function Macro Index,  Up: Top
  1705.  
  1706. Concept Index
  1707. *************
  1708.  
  1709. * Menu:
  1710.  
  1711. * Content types:                        Content Types.
  1712. * Defining Functions In Place:          LAMBDA.
  1713. * Function definitions with LAMBDA:     LAMBDA.
  1714. * Types of storable data:               Content Types.
  1715.  
  1716.  
  1718. Tag Table:
  1719. Node: Top1254
  1720. Node: Copying3031
  1721. Node: Contributors3164
  1722. Node: Installation4235
  1723. Node: Trouble10725
  1724. Node: Overview10965
  1725. Node: Organization13490
  1726. Node: Conventions16574
  1727. Node: Content Types20546
  1728. Node: Creating21688
  1729. Node: Basic Creating21871
  1730. Node: Keyed Creating22300
  1731. Node: Freeing22417
  1732. Node: Adding22833
  1733. Node: Basic Adding23067
  1734. Node: Keyed Adding24334
  1735. Node: Indexed Adding24822
  1736. Node: Removing26515
  1737. Node: Basic Removing26764
  1738. Node: Keyed Removing26850
  1739. Node: Indexed Removing26961
  1740. Node: Replacing27082
  1741. Node: Basic Replacing27315
  1742. Node: Keyed Replacing27404
  1743. Node: Indexed Replacing27519
  1744. Node: Enumerating27643
  1745. Node: Safe vs Unsafe Enumerating28802
  1746. Node: Basic Enumerating29376
  1747. Node: Keyed Enumerating31130
  1748. Node: Indexed Enumerating31290
  1749. Node: LAMBDA32896
  1750. Node: Duplicating35591
  1751. Node: Archiving35782
  1752. Node: Querying36223
  1753. Node: Basic Querying36430
  1754. Node: Keyed Querying36909
  1755. Node: Indexed Querying37051
  1756. Node: Sorting37174
  1757. Node: Classes37308
  1758. Node: Set37849
  1759. Node: Bag37954
  1760. Node: Bag Adding38374
  1761. Node: Bag Removing38625
  1762. Node: Dictionary38897
  1763. Node: MappedCollector39038
  1764. Node: Array39196
  1765. Node: Array Capacity Management39722
  1766. Node: Stack40140
  1767. Node: Stack Methods40654
  1768. Node: Queue41009
  1769. Node: GapArray41093
  1770. Node: LinkedList41182
  1771. Node: BinaryTree41276
  1772. Node: RBTree41368
  1773. Node: SplayTree41459
  1774. Node: EltNodeCollector41556
  1775. Node: Collection41657
  1776. Node: KeyedCollection41956
  1777. Node: IndexedCollection42381
  1778. Node: Projects42879
  1779. Node: Protocol Index56752
  1780. Node: Class Index56886
  1781. Node: Method Function Macro Index57033
  1782. Node: Concept Index61694
  1784. End Tag Table
  1785.